// 后台服务工作者脚本

// 插件安装时的初始化
chrome.runtime.onInstalled.addListener((details) => {
    console.log('烟草订购助手已安装');

    if (details.reason === 'install') {
        // 首次安装
        initializeExtension();
    } else if (details.reason === 'update') {
        // 更新时
        handleExtensionUpdate(details.previousVersion);
    }
});

// 插件启动时
chrome.runtime.onStartup.addListener(() => {
    console.log('烟草订购助手已启动');
    initializeExtension();
});

/**
 * 初始化插件
 */
function initializeExtension() {
    // 设置默认配置
    const defaultSettings = {
        highlight: false,
        quickFillEnabled: true,
        notificationsEnabled: true,
        keyboardShortcuts: true,
        autoBackup: false,
        theme: 'light'
    };

    // 检查并设置默认配置
    chrome.storage.sync.get(Object.keys(defaultSettings), (result) => {
        const updates = {};

        Object.keys(defaultSettings).forEach(key => {
            if (result[key] === undefined) {
                updates[key] = defaultSettings[key];
            }
        });

        if (Object.keys(updates).length > 0) {
            chrome.storage.sync.set(updates, () => {
                console.log('默认设置已初始化:', updates);
            });
        }
    });

    // 设置右键菜单
    setupContextMenus();

    // 设置徽章
    updateBadge();
}

/**
 * 处理插件更新
 */
function handleExtensionUpdate(previousVersion) {
    console.log(`插件从版本 ${previousVersion} 更新到当前版本`);

    // 这里可以添加版本迁移逻辑
    // 例如：数据格式变更、新功能介绍等

    // 显示更新通知
    chrome.notifications.create('update-notification', {
        type: 'basic',
        iconUrl: chrome.runtime.getURL('icons/icon16.png'),
        title: '烟草订购助手已更新',
        message: '插件已更新到最新版本，新增了更多实用功能！'
    });
}

/**
 * 设置右键菜单
 */
function setupContextMenus() {
    // 清除现有菜单
    chrome.contextMenus.removeAll(() => {
        // 创建主菜单
        chrome.contextMenus.create({
            id: 'tobacco-helper-main',
            title: '烟草订购助手',
            contexts: ['page', 'selection']
        });

        // 智能填写菜单（基于API数据）
        chrome.contextMenus.create({
            id: 'intelligent-fill',
            parentId: 'tobacco-helper-main',
            title: '智能填写订单',
            contexts: ['page']
        });

        // 导出数据菜单
        chrome.contextMenus.create({
            id: 'export-data',
            parentId: 'tobacco-helper-main',
            title: '导出订单数据',
            contexts: ['page']
        });

        // 设置菜单
        chrome.contextMenus.create({
            id: 'open-settings',
            parentId: 'tobacco-helper-main',
            title: '打开设置',
            contexts: ['page']
        });

        // 分隔符
        chrome.contextMenus.create({
            id: 'separator1',
            parentId: 'tobacco-helper-main',
            type: 'separator',
            contexts: ['page']
        });

        // 帮助菜单
        chrome.contextMenus.create({
            id: 'help',
            parentId: 'tobacco-helper-main',
            title: '帮助文档',
            contexts: ['page']
        });
    });
}

/**
 * 处理右键菜单点击
 */
chrome.contextMenus.onClicked.addListener((info, tab) => {
    switch (info.menuItemId) {
        case 'intelligent-fill':
            // 智能填写模式：打开弹窗界面进行基于API数据的智能填写
            chrome.action.openPopup();
            break;

        case 'export-data':
            executeContentScript(tab.id, 'exportOrderData');
            break;

        case 'open-settings':
            chrome.runtime.openOptionsPage();
            break;

        case 'help':
            chrome.tabs.create({
                url: chrome.runtime.getURL('help.html')
            });
            break;
    }
});

/**
 * 执行内容脚本函数
 */
function executeContentScript(tabId, functionName, args = []) {
    chrome.scripting.executeScript({
        target: { tabId: tabId },
        function: eval(functionName),
        args: args
    }, (result) => {
        if (chrome.runtime.lastError) {
            console.error('执行脚本失败:', chrome.runtime.lastError.message);
        }
    });
}

/**
 * 监听来自内容脚本的消息
 */
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
    switch (request.action) {
        case 'updateBadge':
            updateBadge(request.text, request.color);
            sendResponse({ success: true });
            break;

        case 'saveOrderData':
            saveOrderData(request.data)
                .then(() => sendResponse({ success: true }))
                .catch(error => sendResponse({ success: false, error: error.message }));
            return true; // 保持消息通道开放

        case 'getOrderHistory':
            getOrderHistory()
                .then(data => sendResponse({ success: true, data: data }))
                .catch(error => sendResponse({ success: false, error: error.message }));
            return true;

        case 'showNotification':
            showNotification(request.title, request.message, request.type);
            sendResponse({ success: true });
            break;

        case 'getSettings':
            // 获取设置数据
            chrome.storage.sync.get(null, (settings) => {
                if (chrome.runtime.lastError) {
                    sendResponse({ success: false, error: chrome.runtime.lastError.message });
                } else {
                    sendResponse({ success: true, settings: settings });
                }
            });
            return true;

        case 'updateSettings':
            chrome.storage.sync.set(request.settings, () => {
                sendResponse({ success: true });
            });
            return true;

        case 'pageUnloading':
            console.log('后台收到页面卸载消息，开始清理缓存...');
            chrome.storage.local.remove('smokingData', () => {
                if (chrome.runtime.lastError) {
                    console.error('清理缓存失败:', chrome.runtime.lastError.message);
                    sendResponse({ success: false, error: chrome.runtime.lastError.message });
                } else {
                    console.log('缓存数据 smokingData 已成功清理。');
                    // 通知popup.js更新UI
                    try {
                        chrome.runtime.sendMessage({ action: 'dataCleared' }, (response) => {
                            if (chrome.runtime.lastError) {
                                console.log('无法通知popup更新UI:', chrome.runtime.lastError.message);
                            }
                        });
                    } catch (error) {
                        console.log('发送消息时出错:', error.message);
                    }
                    sendResponse({ success: true });
                }
            });
            return true; // 保持消息通道开放以进行异步响应

        default:
            sendResponse({ success: false, error: 'Unknown action' });
            break;
    }
});

/**
 * 更新插件徽章
 */
function updateBadge(text = '', color = '#667eea') {
    chrome.action.setBadgeText({ text: text });
    chrome.action.setBadgeBackgroundColor({ color: color });
}

/**
 * 保存订单数据
 */
async function saveOrderData(orderData) {
    try {
        const timestamp = new Date().toISOString();
        const key = `order_${timestamp}`;

        // 保存到本地存储
        await chrome.storage.local.set({
            [key]: {
                ...orderData,
                timestamp: timestamp,
                id: key
            }
        });

        // 更新订单历史索引
        const { orderHistory = [] } = await chrome.storage.local.get('orderHistory');
        orderHistory.unshift(key);

        // 只保留最近100条记录
        if (orderHistory.length > 100) {
            const oldKeys = orderHistory.splice(100);
            // 删除旧的订单数据
            await chrome.storage.local.remove(oldKeys);
        }

        await chrome.storage.local.set({ orderHistory });

        console.log('订单数据已保存:', key);
        return key;
    } catch (error) {
        console.error('保存订单数据失败:', error);
        throw error;
    }
}

/**
 * 获取订单历史
 */
async function getOrderHistory() {
    try {
        const { orderHistory = [] } = await chrome.storage.local.get('orderHistory');

        if (orderHistory.length === 0) {
            return [];
        }

        // 获取最近20条订单的详细数据
        const recentKeys = orderHistory.slice(0, 20);
        const orderData = await chrome.storage.local.get(recentKeys);

        return recentKeys.map(key => orderData[key]).filter(Boolean);
    } catch (error) {
        console.error('获取订单历史失败:', error);
        throw error;
    }
}

/**
 * 显示系统通知
 */
function showNotification(title, message, type = 'basic') {
    const notificationId = `notification_${Date.now()}`;

    chrome.notifications.create(notificationId, {
        type: type,
        iconUrl: chrome.runtime.getURL('icons/icon16.png'),
        title: title,
        message: message
    });

    // 5秒后自动清除通知
    setTimeout(() => {
        chrome.notifications.clear(notificationId);
    }, 5000);
}

/**
 * 监听标签页更新
 */
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
    if (changeInfo.status === 'complete' && tab.url) {
        // 检查是否为目标网站
        if (tab.url.includes('wdk')) {
            // 更新徽章显示活跃状态
            updateBadge('ON', '#28a745');

            // 注入增强功能
            injectEnhancements(tabId);
        } else {
            // 清除徽章
            updateBadge();
        }
    }
});

/**
 * 注入增强功能
 */
function injectEnhancements(tabId) {
    // 注入内容脚本（如果还没有注入）
    chrome.scripting.executeScript({
        target: { tabId: tabId },
        files: ['content.js']
    }).catch(error => {
        // 脚本可能已经注入，忽略错误
        console.log('内容脚本注入状态:', error.message);
    });

    // 注入样式
    chrome.scripting.insertCSS({
        target: { tabId: tabId },
        files: ['content.css']
    }).catch(error => {
        console.log('样式注入状态:', error.message);
    });
}

/**
 * 监听存储变化
 */
chrome.storage.onChanged.addListener((changes, namespace) => {
    console.log('存储变化:', changes, namespace);

    // 如果设置发生变化，通知所有标签页
    if (namespace === 'sync') {
        chrome.tabs.query({}, (tabs) => {
            tabs.forEach(tab => {
                if (tab.url && tab.url.includes('wdk')) {
                    // 检查标签页是否仍然有效
                    chrome.tabs.get(tab.id, (tabInfo) => {
                        if (chrome.runtime.lastError) {
                            // 标签页已关闭或无效，忽略
                            return;
                        }

                        chrome.tabs.sendMessage(tab.id, {
                            action: 'settingsChanged',
                            changes: changes
                        }, (response) => {
                            if (chrome.runtime.lastError) {
                                // 连接失败，可能是content script未加载或标签页已关闭
                                console.log(`无法向标签页 ${tab.id} 发送消息: ${chrome.runtime.lastError.message}`);
                            }
                        });
                    });
                }
            });
        });
    }
});

/**
 * 定期清理旧数据
 */
function cleanupOldData() {
    chrome.storage.local.get(null, (items) => {
        const now = new Date();
        const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);

        const keysToRemove = [];

        Object.keys(items).forEach(key => {
            if (key.startsWith('order_')) {
                const item = items[key];
                if (item.timestamp) {
                    const itemDate = new Date(item.timestamp);
                    if (itemDate < thirtyDaysAgo) {
                        keysToRemove.push(key);
                    }
                }
            }
        });

        if (keysToRemove.length > 0) {
            chrome.storage.local.remove(keysToRemove, () => {
                console.log(`已清理 ${keysToRemove.length} 条过期数据`);
            });
        }
    });
}

// 每天清理一次旧数据
chrome.alarms.create('cleanup', { delayInMinutes: 1, periodInMinutes: 24 * 60 });
chrome.alarms.onAlarm.addListener((alarm) => {
    if (alarm.name === 'cleanup') {
        cleanupOldData();
    }
});

/**
 * 处理插件图标点击
 */
chrome.action.onClicked.addListener((tab) => {
    // 如果没有弹出窗口，这里可以执行默认操作
    console.log('插件图标被点击');
});

/**
 * 错误处理
 */
self.addEventListener('error', (event) => {
    console.error('后台脚本错误:', event.error);
});

self.addEventListener('unhandledrejection', (event) => {
    console.error('未处理的Promise拒绝:', event.reason);
    // 防止错误传播到控制台
    event.preventDefault();
});